/*
 * Copyright 2002-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.baomidou.hibernateplus;

import java.io.File;
import java.io.IOException;
import java.util.Properties;

import javax.sql.DataSource;

import org.hibernate.Interceptor;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.context.spi.CurrentTenantIdentifierResolver;
import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.orm.hibernate5.HibernateExceptionTranslator;
import org.springframework.util.Assert;

import com.baomidou.hibernateplus.enums.Setting;
import com.baomidou.hibernateplus.utils.EntityInfoUtils;

/**
 * {@link FactoryBean} that creates a Hibernate {@link SessionFactory}. This is
 * the usual way to set up a shared Hibernate SessionFactory in a Spring
 * application context; the SessionFactory can then be passed to Hibernate-based
 * data access objects via dependency injection.
 *
 * <p>
 * Compatible with Hibernate 5.0/5.1 as well as 5.2, as of Spring 4.3. Copy
 * LocalSpringSessionFactoryBean
 *
 * @author Juergen Hoeller
 * @since 4.2
 * @see #setDataSource
 * @see #setPackagesToScan
 * @see HibernateSpringSessionFactoryBuilder
 *
 */
public class HibernateSpringSessionFactoryBean extends HibernateExceptionTranslator implements FactoryBean<SessionFactory>,
		ResourceLoaderAware, InitializingBean, DisposableBean {

	private DataSource dataSource;

	private Resource[] configLocations;

	private String[] mappingResources;

	private Resource[] mappingLocations;

	private Resource[] cacheableMappingLocations;

	private Resource[] mappingJarLocations;

	private Resource[] mappingDirectoryLocations;

	private Interceptor entityInterceptor;

	private ImplicitNamingStrategy implicitNamingStrategy;

	private PhysicalNamingStrategy physicalNamingStrategy;

	private Object jtaTransactionManager;

	private MultiTenantConnectionProvider multiTenantConnectionProvider;

	private CurrentTenantIdentifierResolver currentTenantIdentifierResolver;

	private TypeFilter[] entityTypeFilters;

	private Properties hibernateProperties;

	private Class<?>[] annotatedClasses;

	private String[] annotatedPackages;

	private String[] packagesToScan;

	private AsyncTaskExecutor bootstrapExecutor;

	private MetadataSources metadataSources;

	private ResourcePatternResolver resourcePatternResolver;

	private Configuration configuration;

	private SessionFactory sessionFactory;

	private Setting setting;

	public void setType(String type) {
		Setting setting = Setting.getSetting(type);
		this.setting = setting;
	}

	/**
	 * Set the DataSource to be used by the SessionFactory. If set, this will
	 * override corresponding settings in Hibernate properties.
	 * <p>
	 * If this is set, the Hibernate settings should not define a connection
	 * provider to avoid meaningless double configuration.
	 */
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}

	/**
	 * Set the location of a single Hibernate XML config file, for example as
	 * classpath resource "classpath:hibernate.cfg.xml".
	 * <p>
	 * Note: Can be omitted when all necessary properties and mapping resources
	 * are specified locally via this bean.
	 * 
	 * @see Configuration#configure(java.net.URL)
	 */
	public void setConfigLocation(Resource configLocation) {
		this.configLocations = new Resource[] { configLocation };
	}

	/**
	 * Set the locations of multiple Hibernate XML config files, for example as
	 * classpath resources
	 * "classpath:hibernate.cfg.xml,classpath:extension.cfg.xml".
	 * <p>
	 * Note: Can be omitted when all necessary properties and mapping resources
	 * are specified locally via this bean.
	 * 
	 * @see Configuration#configure(java.net.URL)
	 */
	public void setConfigLocations(Resource... configLocations) {
		this.configLocations = configLocations;
	}

	/**
	 * Set Hibernate mapping resources to be found in the class path, like
	 * "example.hbm.xml" or "mypackage/example.hbm.xml". Analogous to mapping
	 * entries in a Hibernate XML config file. Alternative to the more generic
	 * setMappingLocations method.
	 * <p>
	 * Can be used to add to mappings from a Hibernate XML config file, or to
	 * specify all mappings locally.
	 * 
	 * @see #setMappingLocations
	 * @see Configuration#addResource
	 */
	public void setMappingResources(String... mappingResources) {
		this.mappingResources = mappingResources;
	}

	/**
	 * Set locations of Hibernate mapping files, for example as classpath
	 * resource "classpath:example.hbm.xml". Supports any resource location via
	 * Spring's resource abstraction, for example relative paths like
	 * "WEB-INF/mappings/example.hbm.xml" when running in an application
	 * context.
	 * <p>
	 * Can be used to add to mappings from a Hibernate XML config file, or to
	 * specify all mappings locally.
	 * 
	 * @see Configuration#addInputStream
	 */
	public void setMappingLocations(Resource... mappingLocations) {
		this.mappingLocations = mappingLocations;
	}

	/**
	 * Set locations of cacheable Hibernate mapping files, for example as web
	 * app resource "/WEB-INF/mapping/example.hbm.xml". Supports any resource
	 * location via Spring's resource abstraction, as long as the resource can
	 * be resolved in the file system.
	 * <p>
	 * Can be used to add to mappings from a Hibernate XML config file, or to
	 * specify all mappings locally.
	 * 
	 * @see Configuration#addCacheableFile(File)
	 */
	public void setCacheableMappingLocations(Resource... cacheableMappingLocations) {
		this.cacheableMappingLocations = cacheableMappingLocations;
	}

	/**
	 * Set locations of jar files that contain Hibernate mapping resources, like
	 * "WEB-INF/lib/example.hbm.jar".
	 * <p>
	 * Can be used to add to mappings from a Hibernate XML config file, or to
	 * specify all mappings locally.
	 * 
	 * @see Configuration#addJar(File)
	 */
	public void setMappingJarLocations(Resource... mappingJarLocations) {
		this.mappingJarLocations = mappingJarLocations;
	}

	/**
	 * Set locations of directories that contain Hibernate mapping resources,
	 * like "WEB-INF/mappings".
	 * <p>
	 * Can be used to add to mappings from a Hibernate XML config file, or to
	 * specify all mappings locally.
	 * 
	 * @see Configuration#addDirectory(File)
	 */
	public void setMappingDirectoryLocations(Resource... mappingDirectoryLocations) {
		this.mappingDirectoryLocations = mappingDirectoryLocations;
	}

	/**
	 * Set a Hibernate entity interceptor that allows to inspect and change
	 * property values before writing to and reading from the database. Will get
	 * applied to any new Session created by this factory.
	 * 
	 * @see Configuration#setInterceptor
	 */
	public void setEntityInterceptor(Interceptor entityInterceptor) {
		this.entityInterceptor = entityInterceptor;
	}

	/**
	 * Set a Hibernate 5.0 ImplicitNamingStrategy for the SessionFactory.
	 * 
	 * @see Configuration#setImplicitNamingStrategy
	 */
	public void setImplicitNamingStrategy(ImplicitNamingStrategy implicitNamingStrategy) {
		this.implicitNamingStrategy = implicitNamingStrategy;
	}

	/**
	 * Set a Hibernate 5.0 PhysicalNamingStrategy for the SessionFactory.
	 * 
	 * @see Configuration#setPhysicalNamingStrategy
	 */
	public void setPhysicalNamingStrategy(PhysicalNamingStrategy physicalNamingStrategy) {
		this.physicalNamingStrategy = physicalNamingStrategy;
	}

	/**
	 * Set the Spring
	 * {@link org.springframework.transaction.jta.JtaTransactionManager} or the
	 * JTA {@link javax.transaction.TransactionManager} to be used with
	 * Hibernate, if any. Implicitly sets up {@code JtaPlatform}.
	 * 
	 * @see HibernateSpringSessionFactoryBuilder#setJtaTransactionManager
	 */
	public void setJtaTransactionManager(Object jtaTransactionManager) {
		this.jtaTransactionManager = jtaTransactionManager;
	}

	/**
	 * Set a {@link MultiTenantConnectionProvider} to be passed on to the
	 * SessionFactory.
	 * 
	 * @since 4.3
	 * @see HibernateSpringSessionFactoryBuilder#setMultiTenantConnectionProvider
	 */
	public void setMultiTenantConnectionProvider(MultiTenantConnectionProvider multiTenantConnectionProvider) {
		this.multiTenantConnectionProvider = multiTenantConnectionProvider;
	}

	/**
	 * Set a {@link CurrentTenantIdentifierResolver} to be passed on to the
	 * SessionFactory.
	 * 
	 * @see HibernateSpringSessionFactoryBuilder#setCurrentTenantIdentifierResolver
	 */
	public void setCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver currentTenantIdentifierResolver) {
		this.currentTenantIdentifierResolver = currentTenantIdentifierResolver;
	}

	/**
	 * Specify custom type filters for Spring-based scanning for entity classes.
	 * <p>
	 * Default is to search all specified packages for classes annotated with
	 * {@code @javax.persistence.Entity}, {@code @javax.persistence.Embeddable}
	 * or {@code @javax.persistence.MappedSuperclass}.
	 * 
	 * @see #setPackagesToScan
	 */
	public void setEntityTypeFilters(TypeFilter... entityTypeFilters) {
		this.entityTypeFilters = entityTypeFilters;
	}

	/**
	 * Set Hibernate properties, such as "hibernate.dialect".
	 * <p>
	 * Note: Do not specify a transaction provider here when using Spring-driven
	 * transactions. It is also advisable to omit connection provider settings
	 * and use a Spring-set DataSource instead.
	 * 
	 * @see #setDataSource
	 */
	public void setHibernateProperties(Properties hibernateProperties) {
		this.hibernateProperties = hibernateProperties;
	}

	/**
	 * Return the Hibernate properties, if any. Mainly available for
	 * configuration through property paths that specify individual keys.
	 */
	public Properties getHibernateProperties() {
		if (this.hibernateProperties == null) {
			this.hibernateProperties = new Properties();
		}
		return this.hibernateProperties;
	}

	/**
	 * Specify annotated entity classes to register with this Hibernate
	 * SessionFactory.
	 * 
	 * @see Configuration#addAnnotatedClass(Class)
	 */
	public void setAnnotatedClasses(Class<?>... annotatedClasses) {
		this.annotatedClasses = annotatedClasses;
	}

	/**
	 * Specify the names of annotated packages, for which package-level
	 * annotation metadata will be read.
	 * 
	 * @see Configuration#addPackage(String)
	 */
	public void setAnnotatedPackages(String... annotatedPackages) {
		this.annotatedPackages = annotatedPackages;
	}

	/**
	 * Specify packages to search for autodetection of your entity classes in
	 * the classpath. This is analogous to Spring's component-scan feature (
	 * {@link org.springframework.context.annotation.ClassPathBeanDefinitionScanner}
	 * ).
	 */
	public void setPackagesToScan(String... packagesToScan) {
		this.packagesToScan = packagesToScan;
	}

	/**
	 * Specify an asynchronous executor for background bootstrapping, e.g. a
	 * {@link org.springframework.core.task.SimpleAsyncTaskExecutor}.
	 * <p>
	 * {@code SessionFactory} initialization will then switch into background
	 * bootstrap mode, with a {@code SessionFactory} proxy immediately returned
	 * for injection purposes instead of waiting for Hibernate's bootstrapping
	 * to complete. However, note that the first actual call to a
	 * {@code SessionFactory} method will then block until Hibernate's
	 * bootstrapping completed, if not ready by then. For maximum benefit, make
	 * sure to avoid early {@code SessionFactory} calls in init methods of
	 * related beans, even for metadata introspection purposes.
	 * 
	 * @see HibernateSpringSessionFactoryBuilder#buildSessionFactory(AsyncTaskExecutor)
	 * @since 4.3
	 */
	public void setBootstrapExecutor(AsyncTaskExecutor bootstrapExecutor) {
		this.bootstrapExecutor = bootstrapExecutor;
	}

	/**
	 * Specify a Hibernate {@link MetadataSources} service to use (e.g. reusing
	 * an existing one), potentially populated with a custom Hibernate bootstrap
	 * {@link org.hibernate.service.ServiceRegistry} as well.
	 * 
	 * @since 4.3
	 */
	public void setMetadataSources(MetadataSources metadataSources) {
		Assert.notNull(metadataSources, "MetadataSources must not be null");
		this.metadataSources = metadataSources;
	}

	/**
	 * Determine the Hibernate {@link MetadataSources} to use.
	 * <p>
	 * Can also be externally called to initialize and pre-populate a
	 * {@link MetadataSources} instance which is then going to be used for
	 * {@link SessionFactory} building.
	 * 
	 * @return the MetadataSources to use (never {@code null})
	 * @since 4.3
	 * @see HibernateSpringSessionFactoryBuilder#HibernateSpringSessionFactoryBuilder(DataSource,
	 *      ResourceLoader, MetadataSources)
	 */
	public MetadataSources getMetadataSources() {
		if (this.metadataSources == null) {
			BootstrapServiceRegistryBuilder builder = new BootstrapServiceRegistryBuilder();
			if (this.resourcePatternResolver != null) {
				builder = builder.applyClassLoader(this.resourcePatternResolver.getClassLoader());
			}
			this.metadataSources = new MetadataSources(builder.build());
		}
		return this.metadataSources;
	}

	/**
	 * Specify a Spring {@link ResourceLoader} to use for Hibernate metadata.
	 * 
	 * @param resourceLoader
	 *            the ResourceLoader to use (never {@code null})
	 */
	@Override
	public void setResourceLoader(ResourceLoader resourceLoader) {
		this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
	}

	/**
	 * Determine the Spring {@link ResourceLoader} to use for Hibernate
	 * metadata.
	 * 
	 * @return the ResourceLoader to use (never {@code null})
	 * @since 4.3
	 */
	public ResourceLoader getResourceLoader() {
		if (this.resourcePatternResolver == null) {
			this.resourcePatternResolver = new PathMatchingResourcePatternResolver();
		}
		return this.resourcePatternResolver;
	}

	@Override
	public void afterPropertiesSet() throws IOException {
		HibernateSpringSessionFactoryBuilder sfb = new HibernateSpringSessionFactoryBuilder(this.dataSource, getResourceLoader(),
				getMetadataSources());

		if (this.configLocations != null) {
			for (Resource resource : this.configLocations) {
				// Load Hibernate configuration from given location.
				sfb.configure(resource.getURL());
			}
		}

		if (this.mappingResources != null) {
			// Register given Hibernate mapping definitions, contained in
			// resource files.
			for (String mapping : this.mappingResources) {
				Resource mr = new ClassPathResource(mapping.trim(), this.resourcePatternResolver.getClassLoader());
				sfb.addInputStream(mr.getInputStream());
			}
		}

		if (this.mappingLocations != null) {
			// Register given Hibernate mapping definitions, contained in
			// resource files.
			for (Resource resource : this.mappingLocations) {
				sfb.addInputStream(resource.getInputStream());
			}
		}

		if (this.cacheableMappingLocations != null) {
			// Register given cacheable Hibernate mapping definitions, read from
			// the file system.
			for (Resource resource : this.cacheableMappingLocations) {
				sfb.addCacheableFile(resource.getFile());
			}
		}

		if (this.mappingJarLocations != null) {
			// Register given Hibernate mapping definitions, contained in jar
			// files.
			for (Resource resource : this.mappingJarLocations) {
				sfb.addJar(resource.getFile());
			}
		}

		if (this.mappingDirectoryLocations != null) {
			// Register all Hibernate mapping definitions in the given
			// directories.
			for (Resource resource : this.mappingDirectoryLocations) {
				File file = resource.getFile();
				if (!file.isDirectory()) {
					throw new IllegalArgumentException("Mapping directory location [" + resource
							+ "] does not denote a directory");
				}
				sfb.addDirectory(file);
			}
		}

		if (this.entityInterceptor != null) {
			sfb.setInterceptor(this.entityInterceptor);
		}

		if (this.implicitNamingStrategy != null) {
			sfb.setImplicitNamingStrategy(this.implicitNamingStrategy);
		}

		if (this.physicalNamingStrategy != null) {
			sfb.setPhysicalNamingStrategy(this.physicalNamingStrategy);
		}

		if (this.jtaTransactionManager != null) {
			sfb.setJtaTransactionManager(this.jtaTransactionManager);
		}

		if (this.multiTenantConnectionProvider != null) {
			sfb.setMultiTenantConnectionProvider(this.multiTenantConnectionProvider);
		}

		if (this.currentTenantIdentifierResolver != null) {
			sfb.setCurrentTenantIdentifierResolver(this.currentTenantIdentifierResolver);
		}

		if (this.entityTypeFilters != null) {
			sfb.setEntityTypeFilters(this.entityTypeFilters);
		}

		if (this.hibernateProperties != null) {
			sfb.addProperties(this.hibernateProperties);
		}

		if (this.annotatedClasses != null) {
			sfb.addAnnotatedClasses(this.annotatedClasses);
		}

		if (this.annotatedPackages != null) {
			sfb.addPackages(this.annotatedPackages);
		}

		if (this.packagesToScan != null) {
			sfb.scanPackages(this.packagesToScan);
		}

		// Build SessionFactory instance.
		this.configuration = sfb;
		this.sessionFactory = buildSessionFactory(sfb);
		// TODO Caratacus 自动注入sessionFactory
		EntityInfoUtils.initSession(sessionFactory,setting);
	}

	/**
	 * Subclasses can override this method to perform custom initialization of
	 * the SessionFactory instance, creating it via the given Configuration
	 * object that got prepared by this LocalSessionFactoryBean.
	 * <p>
	 * The default implementation invokes LocalSessionFactoryBuilder's
	 * buildSessionFactory. A custom implementation could prepare the instance
	 * in a specific way (e.g. applying a custom ServiceRegistry) or use a
	 * custom SessionFactoryImpl subclass.
	 * 
	 * @param sfb
	 *            LocalSessionFactoryBuilder prepared by this
	 *            LocalSessionFactoryBean
	 * @return the SessionFactory instance
	 * @see HibernateSpringSessionFactoryBuilder#buildSessionFactory
	 */
	protected SessionFactory buildSessionFactory(HibernateSpringSessionFactoryBuilder sfb) {
		return (this.bootstrapExecutor != null ? sfb.buildSessionFactory(this.bootstrapExecutor) : sfb.buildSessionFactory());
	}

	/**
	 * Return the Hibernate Configuration object used to build the
	 * SessionFactory. Allows for access to configuration metadata stored there
	 * (rarely needed).
	 * 
	 * @throws IllegalStateException
	 *             if the Configuration object has not been initialized yet
	 */
	public final Configuration getConfiguration() {
		if (this.configuration == null) {
			throw new IllegalStateException("Configuration not initialized yet");
		}
		return this.configuration;
	}

	@Override
	public SessionFactory getObject() {
		return this.sessionFactory;
	}

	@Override
	public Class<?> getObjectType() {
		return (this.sessionFactory != null ? this.sessionFactory.getClass() : SessionFactory.class);
	}

	@Override
	public boolean isSingleton() {
		return true;
	}

	@Override
	public void destroy() {
		this.sessionFactory.close();
	}

}
